home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / sh / include / asm / uaccess.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  7.6 KB  |  259 lines
  1. #ifndef __ASM_SH_UACCESS_H
  2. #define __ASM_SH_UACCESS_H
  3.  
  4. #include <linux/errno.h>
  5. #include <linux/sched.h>
  6. #include <asm/segment.h>
  7.  
  8. #define VERIFY_READ    0
  9. #define VERIFY_WRITE   1
  10.  
  11. #define __addr_ok(addr) \
  12.     ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
  13.  
  14. /*
  15.  * __access_ok: Check if address with size is OK or not.
  16.  *
  17.  * Uhhuh, this needs 33-bit arithmetic. We have a carry..
  18.  *
  19.  * sum := addr + size;  carry? --> flag = true;
  20.  * if (sum >= addr_limit) flag = true;
  21.  */
  22. #define __access_ok(addr, size)        \
  23.     (__addr_ok((addr) + (size)))
  24. #define access_ok(type, addr, size)    \
  25.     (__chk_user_ptr(addr),        \
  26.      __access_ok((unsigned long __force)(addr), (size)))
  27.  
  28. /*
  29.  * Uh, these should become the main single-value transfer routines ...
  30.  * They automatically use the right size if we just have the right
  31.  * pointer type ...
  32.  *
  33.  * As SuperH uses the same address space for kernel and user data, we
  34.  * can just do these as direct assignments.
  35.  *
  36.  * Careful to not
  37.  * (a) re-use the arguments for side effects (sizeof is ok)
  38.  * (b) require any knowledge of processes at this stage
  39.  */
  40. #define put_user(x,ptr)        __put_user_check((x), (ptr), sizeof(*(ptr)))
  41. #define get_user(x,ptr)        __get_user_check((x), (ptr), sizeof(*(ptr)))
  42.  
  43. /*
  44.  * The "__xxx" versions do not do address space checking, useful when
  45.  * doing multiple accesses to the same area (the user has to do the
  46.  * checks by hand with "access_ok()")
  47.  */
  48. #define __put_user(x,ptr)    __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
  49. #define __get_user(x,ptr)    __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  50.  
  51. struct __large_struct { unsigned long buf[100]; };
  52. #define __m(x) (*(struct __large_struct __user *)(x))
  53.  
  54. #define __get_user_nocheck(x,ptr,size)                \
  55. ({                                \
  56.     long __gu_err;                        \
  57.     unsigned long __gu_val;                    \
  58.     const __typeof__(*(ptr)) __user *__gu_addr = (ptr);    \
  59.     __chk_user_ptr(ptr);                    \
  60.     __get_user_size(__gu_val, __gu_addr, (size), __gu_err);    \
  61.     (x) = (__typeof__(*(ptr)))__gu_val;            \
  62.     __gu_err;                        \
  63. })
  64.  
  65. #define __get_user_check(x,ptr,size)                    \
  66. ({                                    \
  67.     long __gu_err = -EFAULT;                    \
  68.     unsigned long __gu_val = 0;                    \
  69.     const __typeof__(*(ptr)) *__gu_addr = (ptr);            \
  70.     if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))        \
  71.         __get_user_size(__gu_val, __gu_addr, (size), __gu_err);    \
  72.     (x) = (__typeof__(*(ptr)))__gu_val;                \
  73.     __gu_err;                            \
  74. })
  75.  
  76. #define __put_user_nocheck(x,ptr,size)                \
  77. ({                                \
  78.     long __pu_err;                        \
  79.     __typeof__(*(ptr)) __user *__pu_addr = (ptr);        \
  80.     __typeof__(*(ptr)) __pu_val = x;            \
  81.     __chk_user_ptr(ptr);                    \
  82.     __put_user_size(__pu_val, __pu_addr, (size), __pu_err);    \
  83.     __pu_err;                        \
  84. })
  85.  
  86. #define __put_user_check(x,ptr,size)                \
  87. ({                                \
  88.     long __pu_err = -EFAULT;                \
  89.     __typeof__(*(ptr)) __user *__pu_addr = (ptr);        \
  90.     __typeof__(*(ptr)) __pu_val = x;            \
  91.     if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))    \
  92.         __put_user_size(__pu_val, __pu_addr, (size),    \
  93.                 __pu_err);            \
  94.     __pu_err;                        \
  95. })
  96.  
  97. #ifdef CONFIG_SUPERH32
  98. # include "uaccess_32.h"
  99. #else
  100. # include "uaccess_64.h"
  101. #endif
  102.  
  103. /* Generic arbitrary sized copy.  */
  104. /* Return the number of bytes NOT copied */
  105. __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
  106.  
  107. static __always_inline unsigned long
  108. __copy_from_user(void *to, const void __user *from, unsigned long n)
  109. {
  110.     return __copy_user(to, (__force void *)from, n);
  111. }
  112.  
  113. static __always_inline unsigned long __must_check
  114. __copy_to_user(void __user *to, const void *from, unsigned long n)
  115. {
  116.     return __copy_user((__force void *)to, from, n);
  117. }
  118.  
  119. #define __copy_to_user_inatomic __copy_to_user
  120. #define __copy_from_user_inatomic __copy_from_user
  121.  
  122. /*
  123.  * Clear the area and return remaining number of bytes
  124.  * (on failure.  Usually it's 0.)
  125.  */
  126. __kernel_size_t __clear_user(void *addr, __kernel_size_t size);
  127.  
  128. #define clear_user(addr,n)                        \
  129. ({                                    \
  130.     void __user * __cl_addr = (addr);                \
  131.     unsigned long __cl_size = (n);                    \
  132.                                     \
  133.     if (__cl_size && access_ok(VERIFY_WRITE,            \
  134.         ((unsigned long)(__cl_addr)), __cl_size))        \
  135.         __cl_size = __clear_user(__cl_addr, __cl_size);        \
  136.                                     \
  137.     __cl_size;                            \
  138. })
  139.  
  140. /**
  141.  * strncpy_from_user: - Copy a NUL terminated string from userspace.
  142.  * @dst:   Destination address, in kernel space.  This buffer must be at
  143.  *         least @count bytes long.
  144.  * @src:   Source address, in user space.
  145.  * @count: Maximum number of bytes to copy, including the trailing NUL.
  146.  *
  147.  * Copies a NUL-terminated string from userspace to kernel space.
  148.  *
  149.  * On success, returns the length of the string (not including the trailing
  150.  * NUL).
  151.  *
  152.  * If access to userspace fails, returns -EFAULT (some data may have been
  153.  * copied).
  154.  *
  155.  * If @count is smaller than the length of the string, copies @count bytes
  156.  * and returns @count.
  157.  */
  158. #define strncpy_from_user(dest,src,count)                \
  159. ({                                    \
  160.     unsigned long __sfu_src = (unsigned long)(src);            \
  161.     int __sfu_count = (int)(count);                    \
  162.     long __sfu_res = -EFAULT;                    \
  163.                                     \
  164.     if (__access_ok(__sfu_src, __sfu_count))            \
  165.         __sfu_res = __strncpy_from_user((unsigned long)(dest),    \
  166.                 __sfu_src, __sfu_count);        \
  167.                                     \
  168.     __sfu_res;                            \
  169. })
  170.  
  171. static inline unsigned long
  172. copy_from_user(void *to, const void __user *from, unsigned long n)
  173. {
  174.     unsigned long __copy_from = (unsigned long) from;
  175.     __kernel_size_t __copy_size = (__kernel_size_t) n;
  176.  
  177.     if (__copy_size && __access_ok(__copy_from, __copy_size))
  178.         return __copy_user(to, from, __copy_size);
  179.  
  180.     return __copy_size;
  181. }
  182.  
  183. static inline unsigned long
  184. copy_to_user(void __user *to, const void *from, unsigned long n)
  185. {
  186.     unsigned long __copy_to = (unsigned long) to;
  187.     __kernel_size_t __copy_size = (__kernel_size_t) n;
  188.  
  189.     if (__copy_size && __access_ok(__copy_to, __copy_size))
  190.         return __copy_user(to, from, __copy_size);
  191.  
  192.     return __copy_size;
  193. }
  194.  
  195. /**
  196.  * strnlen_user: - Get the size of a string in user space.
  197.  * @s: The string to measure.
  198.  * @n: The maximum valid length
  199.  *
  200.  * Context: User context only.  This function may sleep.
  201.  *
  202.  * Get the size of a NUL-terminated string in user space.
  203.  *
  204.  * Returns the size of the string INCLUDING the terminating NUL.
  205.  * On exception, returns 0.
  206.  * If the string is too long, returns a value greater than @n.
  207.  */
  208. static inline long strnlen_user(const char __user *s, long n)
  209. {
  210.     if (!__addr_ok(s))
  211.         return 0;
  212.     else
  213.         return __strnlen_user(s, n);
  214. }
  215.  
  216. /**
  217.  * strlen_user: - Get the size of a string in user space.
  218.  * @str: The string to measure.
  219.  *
  220.  * Context: User context only.  This function may sleep.
  221.  *
  222.  * Get the size of a NUL-terminated string in user space.
  223.  *
  224.  * Returns the size of the string INCLUDING the terminating NUL.
  225.  * On exception, returns 0.
  226.  *
  227.  * If there is a limit on the length of a valid string, you may wish to
  228.  * consider using strnlen_user() instead.
  229.  */
  230. #define strlen_user(str)    strnlen_user(str, ~0UL >> 1)
  231.  
  232. /*
  233.  * The exception table consists of pairs of addresses: the first is the
  234.  * address of an instruction that is allowed to fault, and the second is
  235.  * the address at which the program should continue.  No registers are
  236.  * modified, so it is entirely up to the continuation code to figure out
  237.  * what to do.
  238.  *
  239.  * All the routines below use bits of fixup code that are out of line
  240.  * with the main instruction path.  This means when everything is well,
  241.  * we don't even have to jump over them.  Further, they do not intrude
  242.  * on our cache or tlb entries.
  243.  */
  244. struct exception_table_entry {
  245.     unsigned long insn, fixup;
  246. };
  247.  
  248. #if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
  249. #define ARCH_HAS_SEARCH_EXTABLE
  250. #endif
  251.  
  252. int fixup_exception(struct pt_regs *regs);
  253. /* Returns 0 if exception not found and fixup.unit otherwise.  */
  254. unsigned long search_exception_table(unsigned long addr);
  255. const struct exception_table_entry *search_exception_tables(unsigned long addr);
  256.  
  257.  
  258. #endif /* __ASM_SH_UACCESS_H */
  259.